JavaScript（JS）是一种广泛用于前端开发的编程语言，它不仅限于此，还可以用于服务器端开发（通过Node.js）。JavaScript的核心语法包括变量声明、数据类型、运算符、控制结构等。以下是JavaScript的核心语法和变量的详细介绍。

### 1. 变量声明

在JavaScript中，可以使用`var`、`let`和`const`来声明变量。

- **`var`**
  - 函数作用域或全局作用域。
  - 可以重新声明和重新赋值。
  - 存在变量提升（hoisting）。

- **`let`**
  - 块级作用域（`{}`内的代码块）。
  - 可以重新赋值，但不能重新声明。
  - 不存在变量提升。

- **`const`**
  - 块级作用域。
  - 不能重新声明和重新赋值（对于基本类型），但对于对象和数组，可以修改其内容。
  - 不存在变量提升。

**示例：**
```javascript
var a = 10; // 全局或函数作用域
let b = 20; // 块级作用域
const c = 30; // 块级作用域，不可重新赋值

// 重新赋值
a = 15;
b = 25;
// c = 35; // 这会报错，因为const声明的变量不能重新赋值

// 重新声明
var a = 20; // 可以重新声明
// let b = 30; // 这会报错，因为let声明的变量不能重新声明
// const c = 40; // 这会报错，因为const声明的变量不能重新声明

// 块级作用域示例
{
    var x = 1;
    let y = 2;
    const z = 3;
}
console.log(x); // 输出: 1
// console.log(y); // 报错: y is not defined
// console.log(z); // 报错: z is not defined
```

### 2. 数据类型

JavaScript有七种内置数据类型，分为基本类型和引用类型。

- **基本类型**
  - `number`: 表示整数和浮点数。
  - `string`: 表示文本。
  - `boolean`: 表示真（`true`）或假（`false`）。
  - `null`: 表示空值或不存在的对象。
  - `undefined`: 表示未定义的值。
  - `symbol`: 表示唯一的、不可变的值（ES6引入）。
  - `bigint`: 表示任意精度的整数（ES11引入）。

- **引用类型**
  - `object`: 包括对象、数组和函数。

**示例：**
```javascript
let num = 42; // number
let str = "Hello, World!"; // string
let bool = true; // boolean
let n = null; // null
let u = undefined; // undefined
let sym = Symbol("unique"); // symbol
let bigInt = 1234567890123456789012345678901234567890n; // bigint

let obj = { name: "Alice", age: 25 }; // object
let arr = [1, 2, 3, 4, 5]; // array
let func = function() { return "Hello"; }; // function
```

### 3. 运算符

JavaScript支持多种运算符，包括算术运算符、赋值运算符、比较运算符、逻辑运算符等。

- **算术运算符**
  - `+`: 加法
  - `-`: 减法
  - `*`: 乘法
  - `/`: 除法
  - `%`: 取模
  - `++`: 自增
  - `--`: 自减

- **赋值运算符**
  - `=`: 简单赋值
  - `+=`: 加法赋值
  - `-=`: 减法赋值
  - `*=`: 乘法赋值
  - `/=`: 除法赋值
  - `%=`: 取模赋值

- **比较运算符**
  - `==`: 相等（不严格）
  - `===`: 严格相等
  - `!=`: 不相等（不严格）
  - `!==`: 严格不相等
  - `>`: 大于
  - `<`: 小于
  - `>=`: 大于等于
  - `<=`: 小于等于

- **逻辑运算符**
  - `&&`: 逻辑与
  - `||`: 逻辑或
  - `!`: 逻辑非

**示例：**
```javascript
let a = 10;
let b = 5;

console.log(a + b); // 输出: 15
console.log(a - b); // 输出: 5
console.log(a * b); // 输出: 50
console.log(a / b); // 输出: 2
console.log(a % b); // 输出: 0

a += 5; // 等同于 a = a + 5
console.log(a); // 输出: 15

console.log(a == b); // 输出: false
console.log(a === b); // 输出: false
console.log(a > b); // 输出: true

console.log(a && b); // 输出: 5 (短路求值)
console.log(a || b); // 输出: 15
console.log(!a); // 输出: false
```

### 4. 控制结构

JavaScript支持多种控制结构，用于控制代码的执行流程。

- **条件语句**
  - `if...else`
  - `switch...case`

- **循环语句**
  - `for`
  - `while`
  - `do...while`
  - `for...in`（用于对象）
  - `for...of`（用于可迭代对象）

- **跳转语句**
  - `break`
  - `continue`
  - `return`

**示例：**
```javascript
// if...else
let score = 85;
if (score >= 90) {
    console.log("优秀");
} else if (score >= 60) {
    console.log("及格");
} else {
    console.log("不及格");
}

// switch...case
let day = 3;
switch (day) {
    case 1:
        console.log("星期一");
        break;
    case 2:
        console.log("星期二");
        break;
    case 3:
        console.log("星期三");
        break;
    default:
        console.log("其他");
}

// for 循环
for (let i = 0; i < 5; i++) {
    console.log(i);
}

// while 循环
let i = 0;
while (i < 5) {
    console.log(i);
    i++;
}

// do...while 循环
let j = 0;
do {
    console.log(j);
    j++;
} while (j < 5);

// for...in 循环（对象）
let obj = { a: 1, b: 2, c: 3 };
for (let key in obj) {
    console.log(key + ": " + obj[key]);
}

// for...of 循环（数组）
let arr = [1, 2, 3, 4, 5];
for (let value of arr) {
    console.log(value);
}
```

### 5. 函数

函数是JavaScript的核心概念之一，用于封装可重用的代码块。

- **函数声明**
  - 使用`function`关键字声明。

- **函数表达式**
  - 将函数赋值给一个变量。

- **箭头函数**
  - ES6引入的简洁函数语法。

**示例：**
```javascript
// 函数声明
function greet(name) {
    return "Hello, " + name + "!";
}
console.log(greet("Alice")); // 输出: Hello, Alice!

// 函数表达式
let greet2 = function(name) {
    return "Hello, " + name + "!";
};
console.log(greet2("Bob")); // 输出: Hello, Bob!

// 箭头函数
let greet3 = (name) => {
    return "Hello, " + name + "!";
};
console.log(greet3("Charlie")); // 输出: Hello, Charlie!

// 简化箭头函数
let greet4 = name => "Hello, " + name + "!";
console.log(greet4("David")); // 输出: Hello, David!
```

### 6. 对象

对象是JavaScript中用于存储键值对的数据结构。

- **创建对象**
  - 使用对象字面量。
  - 使用`new Object()`语法。

- **访问对象属性**
  - 点符号（`.`）。
  - 方括号符号（`[]`）。

**示例：**
```javascript
// 对象字面量
let person = {
    name: "Alice",
    age: 25,
    greet: function() {
        return "Hello, my name is " + this.name;
    }
};

console.log(person.name); // 输出: Alice
console.log(person["age"]); // 输出: 25
console.log(person.greet()); // 输出: Hello, my name is Alice

// 使用 new Object()
let person2 = new Object();
person2.name = "Bob";
person2.age = 30;
person2.greet = function() {
    return "Hello, my name is " + this.name;
};

console.log(person2.name); // 输出: Bob
console.log(person2.age); // 输出: 30
console.log(person2.greet()); // 输出: Hello, my name is Bob
```

### 7. 数组

数组是用于存储多个值的特殊对象。

- **创建数组**
  - 使用数组字面量。
  - 使用`new Array()`语法。

- **访问数组元素**
  - 使用索引（从0开始）。

**示例：**
```javascript
// 数组字面量
let fruits = ["apple", "banana", "cherry"];
console.log(fruits[0]); // 输出: apple
console.log(fruits.length); // 输出: 3

// 使用 new Array()
let fruits2 = new Array("apple", "banana", "cherry");
console.log(fruits2[1]); // 输出: banana

// 数组方法
fruits.push("date"); // 添加元素到数组末尾
console.log(fruits); // 输出: ["apple", "banana", "cherry", "date"]

fruits.pop(); // 移除数组末尾的元素
console.log(fruits); // 输出: ["apple", "banana", "cherry"]

fruits.shift(); // 移除数组开头的元素
console.log(fruits); // 输出: ["banana", "cherry"]

fruits.unshift("apple"); // 添加元素到数组开头
console.log(fruits); // 输出: ["apple", "banana", "cherry"]
```

### 总结

- **变量声明**：使用`var`、`let`和`const`。
- **数据类型**：包括基本类型和引用类型。
- **运算符**：包括算术运算符、赋值运算符、比较运算符和逻辑运算符。
- **控制结构**：包括条件语句、循环语句和跳转语句。
- **函数**：用于封装可重用的代码块。
- **对象**：用于存储键值对。
- **数组**：用于存储多个值。

掌握这些核心语法和变量声明是学习JavaScript的基础，可以帮助你编写更高效和可维护的代码。